home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / ObjArray.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  6KB  |  319 lines
  1. //$ObjArray,ObjArrayIter$
  2. #include "ObjArray.h"
  3. #include "Error.h"
  4. #include "Storage.h"
  5. #include "FixedStorage.h"
  6. #include "String.h"
  7.  
  8. typedef int (*COMPARE)(const void*, const void*);
  9.  
  10. #ifndef __GNUG__
  11.     extern "C" void qsort(void*, int, int, COMPARE);
  12. #endif
  13.  
  14. char *cOutOfBoundsError= "out of bounds %d size %d in 0x%x";
  15. char *cMethodName= "operator[]";
  16.  
  17. //---- class ObjArray ---------------------------------------------------------
  18.  
  19. MetaImpl(ObjArray, (T(lb), TVP(cont,size), 0));
  20.  
  21. ObjArray::ObjArray(int s, int lowerBound)                
  22. { 
  23.     if (s <= 0)
  24.     s= 10;
  25.     cont= new ObjPtr[size= s];
  26.     lb= lowerBound;
  27. }
  28.  
  29. ObjArray::~ObjArray()
  30. {
  31.     SafeDelete(cont);
  32. }
  33.  
  34. void ObjArray::InitNew()
  35. {
  36.     cont= new ObjPtr[cCollectionInitCap];
  37.     lb= 0;
  38. }
  39.  
  40. void ObjArray::FreeAll()
  41. {
  42.     register int i;
  43.  
  44.     for (i= 0; i < size; i++) {
  45.     if (cont[i]) {
  46.         cont[i]->FreeAll();
  47.         SafeDelete(cont[i]);
  48.     }
  49.     }
  50.     size= 0;
  51. }
  52.  
  53. ObjPtr ObjArray::RemoveAt(int i)
  54. { 
  55.     ObjPtr t;
  56.  
  57.     if (!BoundsOk("RemoveAt", i))
  58.     return 0;
  59.     t= cont[i-lb];
  60.     cont[i-lb]= 0; 
  61.     Changed();
  62.     return t;
  63. }
  64.  
  65. ObjPtr ObjArray::Remove(ObjPtr a)
  66. {   
  67.     register int i;
  68.     register ObjPtr op;
  69.  
  70.     for (i = 0; i < size; i++) {
  71.     op= cont[i];
  72.     if (op && op->IsEqual(a)) {
  73.         cont[i]= 0;
  74.         Changed();
  75.         return op;
  76.     }
  77.     }
  78.     return 0;
  79. }
  80.  
  81. ObjPtr ObjArray::RemovePtr(ObjPtr a)
  82. {   
  83.     register int i;
  84.     register ObjPtr op;
  85.  
  86.     for (i = 0; i < size; i++) {
  87.     op= cont[i];
  88.     if (op && op == a) {
  89.         cont[i]= 0;
  90.         Changed();
  91.         return op;
  92.     }
  93.     }
  94.     return 0;
  95. }
  96.  
  97. void ObjArray::Expand(int newSize)
  98. {
  99.     if (newSize < 0) {
  100.     Error ("Expand", "newSize < 0");
  101.     return;
  102.     }
  103.     if (newSize == size)
  104.     return;
  105.     if (newSize <= size) {
  106.     // if the array is shrinked check whether there are nonempty entries
  107.     for (int j = newSize; j < size; j++)
  108.         if (cont[j] != 0) {
  109.         Error ("Expand", "expand would cut off nonempty entries at %d", j);
  110.         return;
  111.         }
  112.     }            
  113.     cont= (ObjPtr*) Realloc(cont, newSize * sizeof(ObjPtr));
  114.     size= newSize;
  115. }
  116.  
  117. Iterator *ObjArray::MakeIterator()
  118. {
  119.     return new ObjArrayIter(this);
  120. }
  121.  
  122. ObjPtr ObjArray::AtPut(int i, ObjPtr ob)
  123. { 
  124.     if (!BoundsOk ("AtPut", i))
  125.     return 0;
  126.     ObjPtr t= cont[i-lb];
  127.     cont[i-lb]= ob;
  128.     Changed();
  129.     return t;
  130. }
  131.  
  132. void ObjArray::AtPutAndExpand(int i,ObjPtr op)
  133. {
  134.     if (i < lb) {
  135.     Error ("AtPutAndExpand", "out of bounds at %d in %x", i, this);
  136.     return;
  137.     }
  138.     if (i-lb >= size) 
  139.     Expand (max(i, GrowBy(size)));
  140.     cont[i-lb] = op; 
  141.     Changed();
  142. }
  143.  
  144. ObjPtr ObjArray::Add(ObjPtr op)
  145. {
  146.     register int i;
  147.  
  148.     if (cont == 0)
  149.     cont= new ObjPtr[size= 10];
  150.     for (i= 0; i < size; i++)
  151.     if (cont[i] == 0)
  152.         break;
  153.     if (i >= size)
  154.     Expand(GrowBy(size));
  155.     cont[i]= op; 
  156.     Changed();
  157.     return 0;
  158. }
  159.  
  160. int ObjArray::IndexOf (ObjPtr ob)
  161. {
  162.     register int i;
  163.  
  164.     for (i = 0; i < size; i++)
  165.     if (ob && ob->IsEqual(cont[i])) 
  166.         return i+lb;
  167.     return -1;
  168. }
  169.  
  170. int ObjArray::IndexOfPtr (ObjPtr ob)
  171. {
  172.     register int i;
  173.  
  174.     for (i= 0; i < size; i++)
  175.     if (ob == cont[i]) 
  176.         return i+lb;
  177.     return -1;
  178. }
  179.  
  180. ObjPtr ObjArray::At(int i)
  181. {
  182.     if (!BoundsOk("At", i))
  183.     return 0;
  184.     return cont[i-lb];
  185. }
  186.  
  187. int ObjArray::Compare (ObjPtr)
  188. {
  189.     MayNotUse ("Compare");
  190.     return -2;
  191. }
  192.  
  193. bool ObjArray::IsEqual (ObjPtr ob)
  194. {
  195.     if (!ob->IsKindOf(ObjArray))
  196.     return FALSE;
  197.     ObjArray *t = (ObjArray *) ob; 
  198.     if (t->size != size || t->lb != lb)
  199.     return FALSE;
  200.     for (int i= 0; i < Size(); i++) {
  201.     if (cont[i] == 0 && t->cont[i] == 0)
  202.         continue;
  203.     if (cont[i] == 0 || t->cont[i] == 0)
  204.         break;
  205.     if (!cont[i]->IsEqual(t->cont[i]))
  206.         break;
  207.     }
  208.     return i == size;
  209. }
  210.  
  211. ostream& ObjArray::PrintOn(ostream &s)
  212. {
  213.     Object::PrintOn(s); // supress Collection::PrintOn
  214.     s << Size() SP;
  215.     for (int i= 0; i < Size(); i++) 
  216.     s << cont[i] SP;
  217.     return s NL;
  218. }
  219.  
  220. istream& ObjArray::ReadFrom(istream &s)
  221. {
  222.     Object::ReadFrom(s);
  223.     delete cont;
  224.     s >> size;
  225.     cont= new ObjPtr[size];
  226.     for (int i= 0; i < size; i++)
  227.     s >> cont[i];
  228.     return s;
  229. }
  230.  
  231. unsigned long ObjArray::Hash ()
  232. {
  233.     register u_long i, hash;
  234.  
  235.     for (i= hash= size; i < size; i++)
  236.     if (cont[i])
  237.         hash ^= cont[i]->Hash();
  238.     return hash;
  239. }
  240.  
  241. static int CompareFun(ObjPtr* a, ObjPtr* b) 
  242. { 
  243.     if (*a == 0 || *b == 0)
  244.     return 0;
  245.     return (*a)->Compare(*b);
  246. }
  247.  
  248. void ObjArray::Sort(int upto)
  249. {
  250.     qsort(cont, min(size, upto-lb), sizeof(ObjPtr), (COMPARE)CompareFun);
  251. }
  252.  
  253. int ObjArray::BinarySearch(ObjPtr op, int upto)
  254. {
  255.     register int base, position, last, result;
  256.     register Object *op2;
  257.     
  258.     if (op == 0)
  259.     return -1;
  260.     
  261.     base= 0;
  262.     last= min(size, upto-lb) - 1;
  263.     
  264.     while (last >= base) {
  265.     position= (base+last) / 2;
  266.     op2= cont[position];
  267.     if ((op2 == 0) || (result= op->Compare(op2)) == 0)
  268.         return position + lb;
  269.     if (result < 0)
  270.         last= position-1;
  271.     else
  272.         base= position+1;
  273.     }
  274.     return -1;
  275. }
  276.  
  277. //---- class ObjArray -------------------------------------------------------
  278.  
  279. ObjArrayIter::ObjArrayIter(Collection *s)
  280. {
  281.     cs= (ObjArray*)s; ce= 0; 
  282. }
  283.  
  284. ObjArrayIter::~ObjArrayIter()
  285. {
  286. }
  287.  
  288. void *ObjArrayIter::operator new(size_t sz)
  289. {
  290.     return MemPools::Alloc(sz);
  291. }
  292.  
  293. void ObjArrayIter::operator delete(void *vp)
  294. {
  295.     MemPools::Free(vp, sizeof(ObjArrayIter)); 
  296. }
  297.  
  298. void ObjArrayIter::Reset(Collection *s)
  299. {
  300.     if (s == 0)
  301.     s= cs;
  302.     cs= (ObjArray*)s;
  303.     ce= 0;
  304. }
  305.  
  306. ObjPtr ObjArrayIter::operator()()
  307. {
  308.     for (;ce < cs->Size() && cs->cont[ce] == 0; ce++)
  309.     ;
  310.     if (ce < cs->Size())
  311.     return cs->cont[ce++];
  312.     return 0;
  313. }
  314.  
  315. bool ObjArrayIter::Filter(ObjPtr)
  316. {
  317.     return TRUE;
  318. }
  319.